package appModels

import (
	"appService/src/authValid/userAuthType"
	"appService/src/orm/join"
	"errors"
	"github.com/gogf/gf/frame/g"
	"github.com/gogf/gf/util/gvalid"
	"time"
	"xorm.io/builder"
	"xorm.io/xorm"
)

//用户权限管理
type Users struct {
	Uid           string    `json:"uid" xorm:"varchar(128) pk notnull unique"`          //用户ID
	Bid           string    `json:"bid" xorm:"varchar(128) notnull index default('0')"` //所属单位ID branch表的ID
	AccountId     string    `json:"account_id" xorm:"varchar(128) notnull index"`       //用户所属账号ID
	AuthGroupId   string    `json:"auth_group_id" xorm:"varchar(128) notnull index"`    //权限组ID
	Longitude     float64   `json:"longitude" xorm:"decimal(11,8)"`                     //经度
	Latitude      float64   `json:"latitude" xorm:"decimal(11,8)"`                      //纬度
	RegTime       time.Time `json:"reg_time" xorm:"datetime"`                           //注册时间
	LastLoginTime time.Time `json:"last_login_time" xorm:"datetime"`                    //上次登录时间
	LoginTime     time.Time `json:"login_time" xorm:"datetime"`                         //登录时间
	LoginRand     string    `json:"login_rand" xorm:"varchar(256)"`                     //登录随机字串
	LastLoginIp   string    `json:"last_login_ip" xorm:"varchar(128)"`                  //上次登录IP
	LoginIp       string    `json:"login_ip" xorm:"varchar(128)"`                       //登录IP
	Roles         []string  `json:"roles" xorm:"text json"`                             //用户所属角色列表
	Remarks       string    `json:"remarks" xorm:"text"`                                //备注
}

//添加数据校验
func (this *Users) AddValid() error {
	rules := []string{
		"AccountId@required#请选择用户所属账号",
		"AuthGroupId@required#请选择账号所属权限组",
	}
	err := gvalid.CheckStruct(this, rules, nil)
	if err == nil {
		return nil
	} else {
		return errors.New(err.FirstString())
	}
}

//修改数据校验
func (this *Users) EditValid() error {
	rules := []string{
		"AuthGroupId@required#请选择账号所属权限组",
	}
	err := gvalid.CheckStruct(this, rules, nil)
	if err == nil {
		return nil
	} else {
		return errors.New(err.FirstString())
	}
}

//获取模型
func (this *Users) Model() interface{} {
	return new(UserInfo)
}

//获取模型切片
func (this *Users) Slice() interface{} {
	return new([]UserInfo)
}

//初始化数据
func (this *Users) Init(db *xorm.Session, guid string, loginUser *UserInfo) error {
	this.Uid = guid
	this.RegTime = time.Now()
	return nil
}

//添加之前调用，判断是否可添加，设置添加条件等
func (this *Users) AddWhere(db *xorm.Session, loginUser *UserInfo) error {
	db.Where(builder.Eq{
		"account_id":    this.AccountId,
		"auth_group_id": this.AuthGroupId,
	})
	has, err := db.Exist(new(Users))
	if err != nil {
		g.Log().Errorf("添加用户，查询用户是否存在，错误：%v", err)
		return errors.New("添加用户失败")
	}
	if has {
		return errors.New("用户已经存在，请不要重复添加")
	}
	account := new(Account)
	db.Where(builder.Eq{"id": this.AccountId})
	has, err = db.Get(account)
	if err != nil {
		g.Log().Errorf("添加用户，查询账号是否存在，错误：%v", err)
		return errors.New("添加用户失败")
	}
	if !has {
		return errors.New("您添加的用户所属账号不存在")
	}
	if loginUser.Account.Account != userAuthType.SYSTEM_ADMIN_ACCOUNT {
		if account.Account == "root" || account.Account == "admin" {
			return errors.New("您没有添加权限")
		}
		if account.AccountType >= loginUser.Account.AccountType {
			return errors.New("账户【" + account.Account + "】是：" + userAuthType.GetUserTypeName(account.AccountType) + "，您没有权限添加")
		}
	}
	this.Bid = account.Bid
	this.AccountId = account.Id
	return nil
}

//删除之前调用，判断是否可删除，设置删除条件等
func (this *Users) DeleteWhere(db *xorm.Session, loginUser *UserInfo, ids ...string) error {

	list := make([]UserInfo, 0)
	db.Table(new(UserInfo)).Alias("u").In("u.uid", ids)
	join.JoinLeftOuter(db, "a.id = u.account_id", new(Account), "a")
	err := db.Find(&list)
	if err != nil {
		g.Log().Errorf("查询删除用户，错误：%v", err)
		return errors.New("删除用户失败")
	}
	if len(list) == 0 {
		g.Log().Errorf("没有查询到要删除的用户")
		return errors.New("删除用户失败")
	}

	for _, v := range list {
		if loginUser.Account.Account != userAuthType.SYSTEM_ADMIN_ACCOUNT {
			if v.Account.Account == "root" || v.Account.Account == "admin" {
				return errors.New("您没有删除权限")
			}
			if v.Account.AccountType >= loginUser.Account.AccountType {
				return errors.New("账户【" + v.Account.Account + "】是：" + userAuthType.GetUserTypeName(v.Account.AccountType) + "，您没有权限删除")
			}
		}
	}

	db.In("uid", ids)
	return nil
}

//修改之前调用，判断是否可修改，设置修改条件
func (this *Users) EditWhere(db *xorm.Session, loginUser *UserInfo) error {
	if this.Uid == "" {
		return errors.New("请选择要修改的数据")
	}
	u := new(UserInfo)
	db.Table(new(UserInfo)).Alias("u").In("u.uid", this.Uid)
	db.Join(join.LEFT_OUTER, []interface{}{new(Account), "a"}, "a.id = u.account_id")
	has, err := db.Get(u)
	if err != nil {
		g.Log().Errorf("查询删除用户，错误：%v", err)
		return errors.New("删除用户失败")
	}
	if !has {
		return errors.New("修改的用户不存在")
	}
	if loginUser.Account.Account != userAuthType.SYSTEM_ADMIN_ACCOUNT {
		if u.Account.Account == "root" || u.Account.Account == "admin" {
			return errors.New("您没有修改权限")
		}
		if u.Account.AccountType >= loginUser.Account.AccountType {
			return errors.New("账户【" + u.Account.Account + "】是：" + userAuthType.GetUserTypeName(u.Account.AccountType) + "，您没有权限修改")
		}
	}
	this.Bid = u.Account.Bid
	db.Where(builder.Eq{"uid": this.Uid})
	db.MustCols("roles").Omit("account_id")
	return nil
}

//查询一条数据条件
func (this *Users) GetWhere(db *xorm.Session, loginUser *UserInfo, id string) error {
	if id == "" && this.Uid == "" {
		return errors.New("空的ID")
	}
	if id == "" {
		id = this.Uid
	}
	db.Table(new(UserInfo)).Alias("u")
	db.Where(builder.Eq{"u.uid": id})
	if loginUser.Account.Account != userAuthType.SYSTEM_ADMIN_ACCOUNT {
		db.Where(builder.Lte{"a.account_type": loginUser.Account.AccountType})
	}
	db.Join(join.LEFT_OUTER, []interface{}{new(Account), "a"}, "a.id = u.account_id")
	return nil
}

//查询列表条件、查询分页数据条数条件
func (this *Users) ListWhere(db *xorm.Session, loginUser *UserInfo) error {
	db.Table(new(UserInfo)).Alias("u")
	db.Desc("u.reg_time")
	if this.AuthGroupId != "" {
		db.Where(builder.Eq{"u.auth_group_id": this.AuthGroupId})
	}
	if loginUser.Account.Account == userAuthType.SYSTEM_ADMIN_ACCOUNT {
	} else {
		db.Where(builder.And(builder.Lt{"a.account_type": loginUser.Account.AccountType}))
	}
	db.Join(join.LEFT_OUTER, []interface{}{new(Account), "a"}, "a.id = u.account_id")
	return nil
}

//查询分页时条件
func (this *Users) PaginateWhere(db *xorm.Session, loginUser *UserInfo) error {
	return nil
}
